#pragma once

#include <iostream>
#include <fstream>
#include <string>
#include <unordered_map>
#include <sstream>
#include <shared_mutex>
#include <thread>
#include <mutex>
#include <memory>
#include <chrono>
#include <filesystem> // 用于文件修改时间检查

#include <iostream>
#include <chrono>
#include <string>
#include <ctime>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <set>
#include <deque>
#include <string>
#include <vector>
#include <mutex>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <memory>
#include <variant>
#include <random>
#include <chrono>
#include <ctime>
#include <optional>
#include <condition_variable>
#include <utility>
#include <cstddef>
#include <thread>

#include "AppDirectory.h"
#include "KedisMacro.h"
namespace fs = std::filesystem;

class KedisConfig {
private:
    std::unordered_map<std::string, std::string> config_map_; // 存储配置项的键值对
    std::string file_name_ = "redis.conf";                                   // 配置文件路径
    mutable std::shared_mutex mutex_;                         // 读写锁保护 config_map_
    std::filesystem::file_time_type last_modified_;           // 记录文件最后修改时间
    bool running_;                                            // 控制监控线程运行状态

    // 工具函数：去除字符串首尾空白
    std::string trim(const std::string& str);

    // 解析一行配置
    void parseLine(const std::string& line);

    // 加载配置文件（内部使用）
    bool loadConfigInternal();

    // 监控线程函数
    void monitorFile();
public:
    // 构造函数
    KedisConfig(const std::string file_name);

    // 析构函数，停止监控线程
    ~KedisConfig();

    // 启动监控线程并加载初始配置
    bool start();

    // 获取配置值（线程安全，共享锁）
    std::string get(const std::string& key, const std::string& default_value = "") const;

    // 设置配置值（线程安全，独占锁）
    void set(const std::string& key, const std::string& value);

    // 保存配置到文件（线程安全，独占锁）
    bool saveConfig();

    // 打印所有配置项（线程安全，共享锁）
    void printAll() const {
        std::shared_lock<std::shared_mutex> lock(mutex_); // 共享锁（读）
        for (const auto& pair : config_map_) {
            std::cout << pair.first << " = " << pair.second << std::endl;
        }
    }

private:
    std::thread monitor_thread_; // 监控线程
};

// 示例：多线程读写测试
void readConfig(KedisConfig& config, const std::string& key);

void writeConfig(KedisConfig& config, const std::string& key, const std::string& value);

// int main(int argc, char* argv[]) {
// 在程序启动时初始化路径
// AppDirectory::InitializeAppPath(argv[0]);
//     RedisConfig config;

//     // 启动配置加载和监控
//     if (!config.start()) {
//         std::cout << "Failed to start configuration." << std::endl;
//         return 1;
//     }

//     // 创建多个线程进行读写操作
//     std::thread t1(readConfig, std::ref(config), "port");
//     std::thread t2(readConfig, std::ref(config), "bind");
//     std::thread t3(writeConfig, std::ref(config), "port", "6380");

//     // 等待线程完成
//     t1.join();
//     t2.join();
//     t3.join();

//     // 打印最终配置
//     std::cout << "\nFinal configurations:\n";
//     config.printAll();

//     return 0;
// }